/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package accesoDatos;

//import ec.edu.ucuenca.accesoDatos.modelo.SraHorariosPersonas;
import conexion.HibSession;
import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import utils.ClaseGeneral;

/**
 *
 * @author acuenca
 */
public class Consultas implements Serializable {

    private int totalRegistros;
    final String formatoFecha = "dd/MM/yyyy";
    final String formatoTimestamp = "dd/MM/yyyy HH:mm:ss";

    public Consultas() {
    }

    public Object get(Class clase, Serializable id) {
        Session conn = null;
        try {
            conn = HibSession.abrirSesion();
            return conn.get(clase, id);
        } catch (Exception e) {
            return null;
        } finally {
            HibSession.cerrarSesion();
        }
    }

    public Object getSession(Class clase, Serializable id, Session conn) {
        try {
            return conn.get(clase, id);
        } catch (Exception e) {
            return null;
        }
    }

    public int guardar(Object objetoGuardar, int nuevo) {
        Session conn = null;
        try {
            conn = HibSession.abrirSesion();
            conn.getTransaction().begin();
            //cambio a Mayusculas:
            objetoGuardar = transformarObjetoMayusculas(objetoGuardar);
            if (nuevo == 0) {
                conn.update(objetoGuardar);

            } else {
                conn.save(objetoGuardar);
            }
            conn.getTransaction().commit();
            return 1;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        } finally {
            HibSession.cerrarSesion();
        }
    }

    public int guardaroActualizar(Object objetoGuardar) {
        Session conn = null;
        try {
            conn = HibSession.abrirSesion();
            conn.getTransaction().begin();

            if (objetoGuardar.getClass().toString().equals("class java.util.ArrayList")) {
            //En el caso que se quiera guardar una lista:
                for (Object objeto : (List) objetoGuardar) {
                    //cambio a Mayusculas:
                    objeto = transformarObjetoMayusculas(objeto);
                    conn.saveOrUpdate(objeto);
                }
            }else{
            //En el caso que se quiera guardar un objeto
                objetoGuardar = transformarObjetoMayusculas(objetoGuardar);
                conn.saveOrUpdate(objetoGuardar);
            }

            conn.getTransaction().commit();
            return 1;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        } finally {
            HibSession.cerrarSesion();
        }
    }

    public int guardarSinMayusculas(Object objetoGuardar, int nuevo) {
        //Para guardar objetos sin pasar a mayusculas tal como viene
        Session conn = null;
        try {
            conn = HibSession.abrirSesion();
            conn.getTransaction().begin();
            //cambio a Mayusculas:
            //objetoGuardar = transformarObjetoMayusculas(objetoGuardar);
            if (nuevo == 0) {
                conn.merge(objetoGuardar);
                //  conn.update(objetoGuardar);

            } else {
                conn.save(objetoGuardar);
            }
            conn.getTransaction().commit();
            return 1;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        } finally {
            HibSession.cerrarSesion();
        }
    }

    public int eliminar(Object objetoGuardar) {
        Session conn = null;
        try {
            conn = HibSession.abrirSesion();
            conn.getTransaction().begin();

            conn.delete(objetoGuardar);

            conn.getTransaction().commit();
            return 1;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        } finally {
            HibSession.cerrarSesion();
        }
    }

    public int actualiza(Object objetoGuardar, int nuevo) {
        Session conn = null;
        try {
            conn = HibSession.abrirSesion();
            conn.getTransaction().begin();
            //cambio a Mayusculas:
            objetoGuardar = transformarObjetoMayusculas(objetoGuardar);
            if (nuevo == 0) {
                conn.update(objetoGuardar);

            } else {
                conn.save(objetoGuardar);
            }
            conn.getTransaction().commit();
            return 1;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        } finally {
            HibSession.cerrarSesion();
        }
    }

    public int guardarList(List lstObjetoGuardar, int nuevo) {
        Session conn = null;
        try {
            conn = HibSession.abrirSesion();
            conn.getTransaction().begin();
//            objetoGuardar = util.transformarObjetoMayusculas(objetoGuardar);
            for (Iterator<Object> it = lstObjetoGuardar.iterator(); it.hasNext();) {
                Object obj = it.next();
                if (nuevo == 0) {
                    conn.merge(obj);
                } else {
                    conn.save(obj);
                }
            }
            conn.getTransaction().commit();
            return 1;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        } finally {
            HibSession.cerrarSesion();
        }
    }

    public int guardarEditarList(List lstObjetoGuardar, List lstObjetoEditar) {
        Session conn = null;
        try {
            conn = HibSession.abrirSesion();
            conn.getTransaction().begin();
//            objetoGuardar = util.transformarObjetoMayusculas(objetoGuardar);
            for (Iterator<Object> it = lstObjetoGuardar.iterator(); it.hasNext();) {
                Object obj = it.next();
                conn.save(obj);
            }
            for (Iterator<Object> itt = lstObjetoEditar.iterator(); itt.hasNext();) {
                Object obj = itt.next();
                conn.merge(obj);
            }
            conn.getTransaction().commit();
            return 1;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        } finally {
            HibSession.cerrarSesion();
        }
    }

    public int guardarEditarEliminarList(List lstObjetoGuardar, List lstObjetoEditar, List lstObjetoEliminar) {
        Session conn = null;
        try {
            conn = HibSession.abrirSesion();
            conn.getTransaction().begin();
//            objetoGuardar = util.transformarObjetoMayusculas(objetoGuardar);
            if (lstObjetoEliminar != null) {
                for (Iterator<Object> ittt = lstObjetoEliminar.iterator(); ittt.hasNext();) {
                    Object obj = ittt.next();
                    conn.delete(obj);
                }
            }
            if (lstObjetoGuardar != null) {
                for (Iterator<Object> it = lstObjetoGuardar.iterator(); it.hasNext();) {
                    Object obj = it.next();
                    conn.save(obj);
                }
            }
            if (lstObjetoEditar != null) {
                for (Iterator<Object> itt = lstObjetoEditar.iterator(); itt.hasNext();) {
                    Object obj = itt.next();
                    conn.merge(obj);
                }
            }
            conn.getTransaction().commit();
            return 1;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        } finally {
            HibSession.cerrarSesion();
        }
    }

    public int guardarEditarEliminarListUpdate(List lstObjetoGuardar, List lstObjetoEditar, List lstObjetoEliminar) {
        Session conn = null;
        try {
            conn = HibSession.abrirSesion();
            conn.getTransaction().begin();
//            objetoGuardar = util.transformarObjetoMayusculas(objetoGuardar);
            if (lstObjetoEliminar != null) {
                for (Iterator<Object> ittt = lstObjetoEliminar.iterator(); ittt.hasNext();) {
                    Object obj = ittt.next();
                    conn.delete(obj);
                }
            }
            if (lstObjetoGuardar != null) {
                for (Iterator<Object> it = lstObjetoGuardar.iterator(); it.hasNext();) {
                    Object obj = it.next();
                    conn.save(obj);
                }
            }
            if (lstObjetoEditar != null) {
                for (Iterator<Object> itt = lstObjetoEditar.iterator(); itt.hasNext();) {
                    Object obj = itt.next();
                    conn.update(obj);
                }
            }
            conn.getTransaction().commit();
            return 1;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        } finally {
            HibSession.cerrarSesion();
        }
    }

    /**
     * Creado: Angel Cuenca
     *
     * @param strSelect : nombre del objeto a retornar, si desea que retorne
     * todo se debe enviar null
     * @param strObj: Nombre de la clase de la cual se obtendrÃ¡n los datos
     * @param strWhere: predicado de la consulta hql
     * @param numRegistros: nÃºmero de registros a recuperar
     * @param numPagina: posiciÃ³n de la paginaciÃ³n
     * @param parametros: parÃ¡metros para en enlace de las variables que se
     * usarÃ¡n con el strWhere tiene la forma tipoDato|nombre|valor
     * @param paginado : utilizado para setear los valores de paginación si es
     * que fue invocado desde el evento getListHqlPaginado
     * @param tipoQuery : tipo de consulta que se va a generar (H:HQL / S:SQL)
     * @return : lista de datos
     */
    private List getList(String strSelect,
            String strObj,
            String strWhere,
            int numRegistros,
            int numPagina,
            List<ParametrosConsulta> parametros,
            String paginado,
            String tipoQuery,
            Session sesion) {
        boolean bandera = false;
        Session conn = null;
        if (sesion == null) {
            conn = HibSession.abrirSesion();
        } else {
            bandera = true;
            conn = sesion;
        }
        try {
            String strSql = null;
            /*
             * Si se trata de una consulta que devuelve todos los objetos
             * encontrados, se ejecutarás la consulta desde el from, caso
             * contrario ejecuta también el comando select con su respectivo
             * objeto a retornar
             */
            strSql = getSqlArmado(strSelect, strObj, strWhere, tipoQuery);
            Query q = null;
            /*
             * Dependiendo del tipo de Consulta creo el query
             */
            if (tipoQuery.equals("H")) {//H:HQL / S:SQL
                q = conn.createQuery(strSql);
            } else {
                q = conn.createSQLQuery(strSql);
            }

            /*
             * Agrego cada uno de los valores a las variables ligadas de la
             * consulta hql
             */
            if (parametros != null) {
                q = this.getQueryParametros(q, parametros);
            }

            /*
             * unicamente se coloca la paginación si es que fue invocado desde
             * el evento getListHqlPaginado
             */
            if (paginado.equals("S")) {
                /*
                 * Tomo el total de registros recuperados
                 */
                this.totalRegistros = q.list().size();
                q.setMaxResults(numRegistros);
                q.setFirstResult(numPagina);
            }
            return q.list();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            /*
             * sólo si no se envió la sesion se la debe cerrar, caso contrario
             * se la debe mantener abierta
             */
            if (!bandera) {
                HibSession.cerrarSesion();
            }
        }
    }
    
    
    
     private List getList(String strSql,
            String tipoQuery,
            List<ParametrosConsulta> parametros,
            Session sesion) {
        boolean bandera = false;
        Session conn = null;
        if (sesion == null) {
            conn = HibSession.abrirSesion();
        } else {
            bandera = true;
            conn = sesion;
        }
        try {
            Query q = null;
            /*
             * Dependiendo del tipo de Consulta creo el query
             */
            if (tipoQuery.equals("H")) {//H:HQL / S:SQL
                q = conn.createQuery(strSql);
            } else {
                q = conn.createSQLQuery(strSql);
            }

            /*
             * Agrego cada uno de los valores a las variables ligadas de la
             * consulta hql
             */
            if (parametros != null) {
                q = this.getQueryParametros(q, parametros);
            }

            /*
             * unicamente se coloca la paginación si es que fue invocado desde
             * el evento getListHqlPaginado
             */
            return q.list();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            /*
             * sólo si no se envió la sesion se la debe cerrar, caso contrario
             * se la debe mantener abierta
             */
            if (!bandera) {
                HibSession.cerrarSesion();
            }
        }
    }
    

    private List getList(String sqlQuery, Session sesion) {
        Session conn = null;

        if (sesion == null) {
            conn = HibSession.abrirSesion();
        } else {
            conn = sesion;
        }
        try {
            return conn.createSQLQuery(sqlQuery).list();
        } catch (Exception e) {
            return null;
        }
    }

    private List getTimestamp(String sqlQuery, Session sesion, Timestamp ts) {
        Session conn = null;
        if (sesion == null) {
            conn = HibSession.abrirSesion();
        } else {
            conn = sesion;
        }
        try {
            Query query = conn.createSQLQuery(sqlQuery);
            query.setTimestamp("timeStampField", ts);
            List list = query.list();
            return list;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * Creado: Angel Cuenca
     *
     * @param q : query a la que se agregará cada uno de los valores de las
     * variables ligadas
     * @param parametros : variable con los valores de las variables ligadas
     * @return q : query listo para ejecutarse
     */
    private Query getQueryParametros(Query q, List<ParametrosConsulta> parametros) {
        try {
            /*
             * Agrego cada uno de los valores a las variables ligadas de la
             * consulta hql
             */
            for (int i = 0; i < parametros.size(); i++) {
                ParametrosConsulta parametro = parametros.get(i);
                if (parametro.getValor() instanceof java.lang.String) {
                    q.setString(parametro.getNombreParametro(), (String) parametro.getValor());
                } else if (parametro.getValor() instanceof java.lang.Boolean) {
                    q.setBoolean(parametro.getNombreParametro(), (Boolean) parametro.getValor());
                } else if (parametro.getValor() instanceof java.lang.Character) {
                    q.setCharacter(parametro.getNombreParametro(), (Character) parametro.getValor());
                } else if (parametro.getValor() instanceof java.math.BigDecimal) {
                    q.setBigDecimal(parametro.getNombreParametro(), (BigDecimal) parametro.getValor());
                } else if (parametro.getValor() instanceof java.lang.Double) {
                    q.setDouble(parametro.getNombreParametro(), (Double) parametro.getValor());
                } else if (parametro.getValor() instanceof java.lang.Integer) {
                    q.setInteger(parametro.getNombreParametro(), (Integer) parametro.getValor());
                } else if (parametro.getValor() instanceof java.lang.Byte) {
                    q.setByte(parametro.getNombreParametro(), (Byte) parametro.getValor());
                } else if (parametro.getValor() instanceof java.lang.Long) {
                    q.setLong(parametro.getNombreParametro(), (Long) parametro.getValor());
                } else if (parametro.getValor() instanceof java.util.Date) {
                    DateFormat myDateFormat = new SimpleDateFormat(formatoFecha);
                    SimpleDateFormat formato = new SimpleDateFormat(formatoFecha);
                    String fechaS = formato.format(parametro.getValor());
                    Date fecha = myDateFormat.parse(fechaS);
                    q.setDate(parametro.getNombreParametro(), fecha);
                } else if (parametro.getValor() instanceof Timestamp) {
                    DateFormat myDateFormat = new SimpleDateFormat(formatoTimestamp);
                    SimpleDateFormat formato = new SimpleDateFormat(formatoTimestamp);
                    String fechaS = formato.format(parametro.getValor());
                    Date fecha = myDateFormat.parse(fechaS);
                    q.setTimestamp(parametro.getNombreParametro(), new java.sql.Timestamp(fecha.getTime()));
                }
            }
            return q;
        } catch (Exception e) {
            return null;
        }

    }

    /**
     * Creado: Angel Cuenca
     *
     * @param strSelect : nombre del objeto a retornar, si desea que retorne
     * todo se debe enviar NULL
     * @param strObj: Nombre de la clase de la cual se obtendrÃ¡n los datos
     * @param strWhere: predicado de la consulta hql
     * @param tipoQuery: predicado de la consulta hql
     * @return strSql : sql listo para ser ejecutado
     */
    private String getSqlArmado(String strSelect, String strObj, String strWhere, String tipoQuery) {
        String strSql = "";
        String where = "where ";
        String from = "from ";
        if (tipoQuery.equals("H")) {//H:HQL - S:SQL
            /*
             * Cuando se debe recuperar un objeto particular
             */
            if (strSelect != null) {
                strSql = String.format("select %s ", strSelect);
            }
        } else {//CUANDO ES SQL
            /*
             * Cuando se debe recuperar ciertos campos de la base de datos
             */
            if (strSelect != null) {
                strSql = String.format("SELECT %s ", strSelect);
            } else {
                strSql = String.format("SELECT * ");
            }
            where = where.toUpperCase();
            from = from.toUpperCase();
        }
        /*
         * Cuando la consulta tiene un predicado
         */
        if (strWhere != null) {
            strSql = String.format(strSql + from + " %s %s", strObj, where + strWhere);
        } else {
            strSql = String.format(strSql + from + " %s ", strObj);
        }
        return strSql;
    }

    /**
     * Creado: Angel Cuenca
     *
     * @param strSelect : nombre del objeto a retornar, si desea que retorne
     * todo se debe enviar NULL
     * @param strObj: Nombre de la clase de la cual se obtendrÃ¡n los datos
     * @param strWhere: predicado de la consulta hql
     * @param numRegistros: numero de registros a recuperar
     * @param numPagina: posicionn de la paginacion
     * @param parametros: parÃ¡metros para en enlace de las variables que se
     * usarÃ¡n con el strWhere tiene la forma tipoDato|nombre|valor
     * @return : lista de datos
     */
    public List getListHqlPaginado(String strSelect,
            String strObj,
            String strWhere,
            int numRegistros,
            int numPagina,
            List<ParametrosConsulta> parametros) {
        try {
            return this.getList(strSelect, strObj, strWhere, numRegistros, numPagina, parametros, "S", "H", null);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * Creado: Angel Cuenca
     *
     * @param strSelect : nombre del objeto a retornar, si desea que retorne
     * todo se debe enviar NULL
     * @param strObj: Nombre de la clase de la cual se obtendrÃ¡n los datos
     * @param strWhere: predicado de la consulta hql
     * @param numRegistros: numero de registros a recuperar
     * @param numPagina: posicionn de la paginacion
     * @param parametros: parÃ¡metros para en enlace de las variables que se
     * usarÃ¡n con el strWhere tiene la forma tipoDato|nombre|valor
     * @param sesion : sesion activa y se la debe mantener abierta
     * @return
     */
    public List getListHqlPaginadoSession(String strSelect,
            String strObj,
            String strWhere,
            int numRegistros,
            int numPagina,
            List<ParametrosConsulta> parametros,
            Session sesion) {
        try {
            return this.getList(strSelect, strObj, strWhere, numRegistros, numPagina, parametros, "S", "H", sesion);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * Creado: Angel Cuenca
     *
     * @param strSelect : nombre del objeto a retornar, si desea que retorne
     * todo se debe enviar null
     * @param strObj: Nombre de la clase de la cual se obtendrÃ¡n los datos
     * @param strWhere: predicado de la consulta hql
     * @param parametros: parÃ¡metros para en enlace de las variables que se
     * usarÃ¡n con el strWhere tiene la forma tipoDato|nombre|valor
     * @return : lista de datos
     */
    public List getListHql(String strSelect,
            String strObj,
            String strWhere,
            List<ParametrosConsulta> parametros) {
        try {
            return this.getList(strSelect, strObj, strWhere, 0, 0, parametros, "N", "H", null);
        } catch (Exception e) {
            return null;
        }
    }
    
    
    //Consulta HQL directa
    public List getListHql(String sql,
            List<ParametrosConsulta> parametros) {
        try {
            return this.getList(sql,"H", parametros, null);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * Creado: Angel Cuenca
     *
     * @param strSelect : nombre del objeto a retornar, si desea que retorne
     * todo se debe enviar null
     * @param strObj: Nombre de la clase de la cual se obtendrÃ¡n los datos
     * @param strWhere: predicado de la consulta hql
     * @param parametros: parÃ¡metros para en enlace de las variables que se
     * usarÃ¡n con el strWhere tiene la forma tipoDato|nombre|valor
     * @param sesion : sesion activa y se la debe no cerrar
     * @return : lista de datos
     */
    public List getListHqlSession(String strSelect,
            String strObj,
            String strWhere,
            List<ParametrosConsulta> parametros,
            Session sesion) {
        try {
            return this.getList(strSelect, strObj, strWhere, 0, 0, parametros, "N", "H", sesion);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * Creado: Angel Cuenca
     *
     * @param strSelect : nombre del objeto a retornar, si desea que retorne
     * todo se debe enviar null
     * @param strObj: Nombre de la clase de la cual se obtendrÃ¡n los datos
     * @param strWhere: predicado de la consulta hql
     * @param parametros: parÃ¡metros para en enlace de las variables que se
     * usarÃ¡n con el strWhere tiene la forma tipoDato|nombre|valor
     * @return
     */
    public Object getOneHql(String strSelect, String strObj, String strWhere, List<ParametrosConsulta> parametros) {
        Session conn = HibSession.abrirSesion();
        try {
            String strSql = null;
            /*
             * Si se trata de una consulta que devuelve todos los objetos
             * encontrados, se ejecutarás la consulta desde el from, caso
             * contrario ejecuta también el comando select con su respectivo
             * objeto a retornar
             */
            strSql = getSqlArmado(strSelect, strObj, strWhere, "H");
            Query q = conn.createQuery(strSql);
            /*
             * Agrego cada uno de los valores a las variables ligadas de la
             * consulta hql
             */
            q = this.getQueryParametros(q, parametros);
            return q.uniqueResult();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            HibSession.cerrarSesion();
        }
    }

    /**
     * Creado: Angel Cuenca
     *
     * @param strSelect : nombre del objeto a retornar, si desea que retorne
     * todo se debe enviar null
     * @param strObj: Nombre de la clase de la cual se obtendrÃ¡n los datos
     * @param strWhere: predicado de la consulta hql
     * @param parametros: parÃ¡metros para en enlace de las variables que se
     * usarÃ¡n con el strWhere tiene la forma tipoDato|nombre|valor
     * @param sesion : session para las consultas
     * @return
     */
    public Object getOneHqlSession(String strSelect, String strObj, String strWhere, List<ParametrosConsulta> parametros, Session sesion) {
        Session conn = null;
        if (sesion == null) {
            conn = HibSession.abrirSesion();
        } else {
            conn = sesion;
        }
        try {
            String strSql = null;
            /*
             * Si se trata de una consulta que devuelve todos los objetos
             * encontrados, se ejecutarás la consulta desde el from, caso
             * contrario ejecuta también el comando select con su respectivo
             * objeto a retornar
             */
            strSql = getSqlArmado(strSelect, strObj, strWhere, "H");
            Query q = conn.createQuery(strSql);
            /*
             * Agrego cada uno de los valores a las variables ligadas de la
             * consulta hql
             */
            q = this.getQueryParametros(q, parametros);
            return q.uniqueResult();
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * Creado: Angel Cuenca
     *
     * @param strCampos : nombre de los campos a retornar, si desea que retorne
     * todo se debe enviar NULL y se coloca (*) implicitamente
     * @param strTablas: Nombre de las tablas de la cual se obtendran los datos
     * @param strWhere: predicado de la consulta hql
     * @param parametros: parametros para en enlace de las variables que se
     * usaran con el strWhere tiene la forma tipoDato|nombre|valor
     * @return
     */
    public List getListSql(String strCampos,
            String strTablas,
            String strWhere,
            List<ParametrosConsulta> parametros) {
        try {
            return this.getList(strCampos, strTablas, strWhere, 0, 0, parametros, "N", "S", null);
        } catch (Exception e) {
            return null;
        }
    }

    public List getListSql(String sqlQuery) {
        try {
            return this.getList(sqlQuery, null);
        } catch (Exception e) {
            return null;
        }
    }
    
    public List getListSql(String sqlQuery,List<ParametrosConsulta> parametros) {
        try {
            return this.getList(sqlQuery, "S", parametros, null);
        } catch (Exception e) {
            return null;
        }
    }

    public List getListSqlClass(String strSelect,
            String strObj,
            String strWhere,
            Class clase,
            List<ParametrosConsulta> parametros) {
        boolean bandera = false;
        Session conn = null;
        conn = HibSession.abrirSesion();
        try {
            String strSql = null;
            /*
             * Si se trata de una consulta que devuelve todos los objetos
             * encontrados, se ejecutarás la consulta desde el from, caso
             * contrario ejecuta también el comando select con su respectivo
             * objeto a retornar
             */
            strSql = getSqlArmado(strSelect, strObj, strWhere, "S");
            Query q = null;
            /*
             * Dependiendo del tipo de Consulta creo el query
             */

            q = conn.createSQLQuery(strSql).addEntity(clase);


            /*
             * Agrego cada uno de los valores a las variables ligadas de la
             * consulta hql
             */
            if (parametros != null) {
                q = this.getQueryParametros(q, parametros);
            }

            /*
             * unicamente se coloca la paginación si es que fue invocado desde
             * el evento getListHqlPaginado
             */
            return q.list();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            /*
             * sólo si no se envió la sesion se la debe cerrar, caso contrario
             * se la debe mantener abierta
             */
            if (!bandera) {
                HibSession.cerrarSesion();
            }
        }
    }
    
    
    
     public List getListSqlClass(String consulta,Class clase,
            List<ParametrosConsulta> parametros) {
        boolean bandera = false;
        Session conn = null;
        conn = HibSession.abrirSesion();
        try {
            String strSql = null;
            /*
             * Si se trata de una consulta que devuelve todos los objetos
             * encontrados, se ejecutarás la consulta desde el from, caso
             * contrario ejecuta también el comando select con su respectivo
             * objeto a retornar
             */
            strSql = consulta;
            Query q = null;
            /*
             * Dependiendo del tipo de Consulta creo el query
             */

            q = conn.createSQLQuery(strSql).addEntity(clase);

            
            if (parametros != null) {
                q = this.getQueryParametros(q, parametros);
            }
            /*
             * unicamente se coloca la paginación si es que fue invocado desde
             * el evento getListHqlPaginado
             */
            return q.list();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            /*
             * sólo si no se envió la sesion se la debe cerrar, caso contrario
             * se la debe mantener abierta
             */
            if (!bandera) {
                HibSession.cerrarSesion();
            }
        }
    }
     
     
     
     
       public List getListSqlClass(String consulta,Class clase) {
        boolean bandera = false;
        Session conn = null;
        conn = HibSession.abrirSesion();
        try {
            String strSql = null;
            /*
             * Si se trata de una consulta que devuelve todos los objetos
             * encontrados, se ejecutarás la consulta desde el from, caso
             * contrario ejecuta también el comando select con su respectivo
             * objeto a retornar
             */
            strSql = consulta;
            Query q = null;
            /*
             * Dependiendo del tipo de Consulta creo el query
             */

            q = conn.createSQLQuery(strSql).addEntity(clase);

            /*
             * unicamente se coloca la paginación si es que fue invocado desde
             * el evento getListHqlPaginado
             */
            return q.list();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            /*
             * sólo si no se envió la sesion se la debe cerrar, caso contrario
             * se la debe mantener abierta
             */
            if (!bandera) {
                HibSession.cerrarSesion();
            }
        }
    }
    

    /**
     * Creado: Angel Cuenca
     *
     * @param strCampos : nombre de los campos a retornar, si desea que retorne
     * todo se debe enviar NULL y se coloca (*) implicitamente
     * @param strTablas: Nombre de las tablas de la cual se obtendran los datos
     * @param strWhere: predicado de la consulta hql
     * @param parametros: parametros para en enlace de las variables que se
     * usaran con el strWhere tiene la forma tipoDato|nombre|valor
     * @param sesion : session para las consultas
     * @return
     */
    public List getListSqlSession(String strCampos,
            String strTablas,
            String strWhere,
            List<ParametrosConsulta> parametros,
            Session sesion) {
        try {
            return this.getList(strCampos, strTablas, strWhere, 0, 0, parametros, "N", "S", sesion);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * Creado: Angel Cuenca
     *
     * @param strCampos : nombre de los campos a retornar, si desea que retorne
     * todo se debe enviar NULL y se coloca (*) implicitamente
     * @param strTablas: Nombre de las tablas de la cual se obtendran los datos
     * @param strWhere: predicado de la consulta hql
     * @param parametros: parametros para en enlace de las variables que se
     * usaran con el strWhere tiene la forma tipoDato|nombre|valor
     * @return
     */
    public List<ClaseGeneral> getListSql(List<ParametrosConsulta> parametros,
            String strCampos,
            String strTablas,
            String strWhere) {
        try {
            List lista = getList(strCampos, strTablas, strWhere, 0, 0, parametros, "N", "S", null);
            List<ClaseGeneral> lstGeneral = new ArrayList();
            for (Iterator it = lista.iterator(); it.hasNext();) {
                Object[] row = (Object[]) it.next();
                ClaseGeneral objeto = new ClaseGeneral();
                Method metodo = null;
                Class[] valorParametro;
                for (int i = 0; i < row.length; i++) {
                    int idAtributo = i + 1;
                    valorParametro = new Class[1];
                    valorParametro[0] = Class.forName("java.lang.Object");
                    metodo = objeto.getClass().getMethod("setCampo" + idAtributo, valorParametro);
                    metodo.invoke(objeto, row[i]);
                }
                lstGeneral.add(objeto);
            }
            return lstGeneral;
        } catch (Exception e) {
            return null;
        }
    }
    
    public List<ClaseGeneral> getListClaseGeneral(List lista) {
        try {
            List<ClaseGeneral> lstGeneral = new ArrayList();
            for (Iterator it = lista.iterator(); it.hasNext();) {
                Object[] row = (Object[]) it.next();
                ClaseGeneral objeto = new ClaseGeneral();
                Method metodo = null;
                Class[] valorParametro;
                for (int i = 0; i < row.length; i++) {
                    int idAtributo = i + 1;
                    valorParametro = new Class[1];
                    valorParametro[0] = Class.forName("java.lang.Object");
                    metodo = objeto.getClass().getMethod("setCampo" + idAtributo, valorParametro);
                    metodo.invoke(objeto, row[i]);
                }
                lstGeneral.add(objeto);
            }
            return lstGeneral;
        } catch (Exception e) {
            return null;
        }
    }
    
    
    

    /**
     * Creado: Elvia Alvarez
     *
     * @param strCampos : nombre de los campos a retornar, si desea que retorne
     * todo se debe enviar NULL y se coloca (*) implicitamente
     * @param strTablas: Nombre de las tablas de la cual se obtendran los datos
     * @param strWhere: predicado de la consulta hql
     * @param numRegistros: numero de registros a recuperar
     * @param numPagina: posicionn de la paginacion
     * @param parametros: parametros para en enlace de las variables que se
     * usaran con el strWhere tiene la forma tipoDato|nombre|valor
     * @return
     */
    public List<ClaseGeneral> getListSqlPaginadoClase(String strCampos,
            String strTablas,
            String strWhere,
            int numRegistros,
            int numPagina,
            List<ParametrosConsulta> parametros) {
        try {
            List lista = getList(strCampos, strTablas, strWhere, numRegistros, numPagina, parametros, "S", "S", null);
            List<ClaseGeneral> lstGeneral = new ArrayList();
            for (Iterator it = lista.iterator(); it.hasNext();) {
                Object[] row = (Object[]) it.next();
                ClaseGeneral objeto = new ClaseGeneral();
                Method metodo = null;
                Class[] valorParametro;
                for (int i = 0; i < row.length; i++) {
                    int idAtributo = i + 1;
                    valorParametro = new Class[1];
                    valorParametro[0] = Class.forName("java.lang.Object");
                    metodo = objeto.getClass().getMethod("setCampo" + idAtributo, valorParametro);
                    metodo.invoke(objeto, row[i]);
                }
                lstGeneral.add(objeto);
            }
            return lstGeneral;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * Creado: Angel Cuenca
     *
     * @param strCampos : nombre de los campos a retornar, si desea que retorne
     * todo se debe enviar NULL y se coloca (*) implicitamente 0, 0
     * @param strTablas: Nombre de las tablas de la cual se obtendran los datos
     * @param strWhere: predicado de la consulta hql
     * @param parametros: parametros para en enlace de las variables que se
     * usaran con el strWhere tiene la forma tipoDato|nombre|valor
     * @param sesion : session para las consultas
     * @return
     */
    public List<ClaseGeneral> getListSqlSession(List<ParametrosConsulta> parametros,
            String strCampos,
            String strTablas,
            String strWhere,
            Session sesion) {
        try {
            List lista = getList(strCampos, strTablas, strWhere, 0, 0, parametros, "N", "S", sesion);
            List<ClaseGeneral> lstGeneral = new ArrayList();
            for (Iterator it = lista.iterator(); it.hasNext();) {
                Object[] row = (Object[]) it.next();
                ClaseGeneral objeto = new ClaseGeneral();
                Method metodo = null;
                Class[] valorParametro;
                for (int i = 0; i < row.length; i++) {
                    int idAtributo = i + 1;
                    valorParametro = new Class[1];
                    valorParametro[0] = Class.forName("java.lang.Object");
                    metodo = objeto.getClass().getMethod("setCampo" + idAtributo, valorParametro);
                    metodo.invoke(objeto, row[i]);
                }
                lstGeneral.add(objeto);
            }
            return lstGeneral;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * Creado: Angel Cuenca
     *
     * @param strCampos : nombre de los campos a retornar, si desea que retorne
     * todo se debe enviar NULL y se coloca (*) implicitamente
     * @param strTablas: Nombre de las tablas de la cual se obtendran los datos
     * @param strWhere: predicado de la consulta hql
     * @param numRegistros: numero de registros a recuperar
     * @param numPagina: posicionn de la paginacion
     * @param parametros: parametros para en enlace de las variables que se
     * usaran con el strWhere tiene la forma tipoDato|nombre|valor
     * @return
     */
    public List getListSqlPaginado(String strCampos,
            String strTablas,
            String strWhere,
            int numRegistros,
            int numPagina,
            List<ParametrosConsulta> parametros) {
        try {
            return this.getList(strCampos, strTablas, strWhere, numRegistros, numPagina, parametros, "S", "S", null);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * Creado: Angel Cuenca
     *
     * @param strCampos : nombre de los campos a retornar, si desea que retorne
     * todo se debe enviar NULL y se coloca (*) implicitamente
     * @param strTablas: Nombre de las tablas de la cual se obtendran los datos
     * @param strWhere: predicado de la consulta hql
     * @param numRegistros: numero de registros a recuperar
     * @param numPagina: posicionn de la paginacion
     * @param parametros: parametros para en enlace de las variables que se
     * usaran con el strWhere tiene la forma tipoDato|nombre|valor
     * @param sesion : session para las consultas
     * @return
     */
    public List getListSqlPaginadoSession(String strCampos,
            String strTablas,
            String strWhere,
            int numRegistros,
            int numPagina,
            List<ParametrosConsulta> parametros,
            Session sesion) {
        try {
            return this.getList(strCampos, strTablas, strWhere, numRegistros, numPagina, parametros, "S", "S", sesion);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * Creado: Angel Cuenca
     *
     * @param strCampos : nombre de los campos a retornar, si desea que retorne
     * todo se debe enviar NULL y se coloca (*) implicitamente
     * @param strTablas: Nombre de las tablas de la cual se obtendran los datos
     * @param strWhere: predicado de la consulta hql
     * @param parametros: parametros para en enlace de las variables que se
     * usaran con el strWhere tiene la forma tipoDato|nombre|valor
     * @return
     */
    public Object getOneSql(String strCampos, String strTablas, String strWhere, List<ParametrosConsulta> parametros) {
        Session conn = HibSession.abrirSesion();
        try {
            String strSql = null;
            /*
             * Si se trata de una consulta que devuelve todos los objetos
             * encontrados, se ejecutarás la consulta desde el from, caso
             * contrario ejecuta también el comando select con su respectivo
             * objeto a retornar
             */
            strSql = getSqlArmado(strCampos, strTablas, strWhere, "S");
            Query q = conn.createSQLQuery(strSql);
            /*
             * Agrego cada uno de los valores a las variables ligadas de la
             * consulta hql
             */
            if (parametros != null) {
                q = this.getQueryParametros(q, parametros);
            }
            return q.uniqueResult();
        } catch (Exception e) {
            return null;
        } finally {
            HibSession.cerrarSesion();
        }
    }

    /**
     * Creado: Angel Cuenca
     *
     * @param strCampos : nombre de los campos a retornar, si desea que retorne
     * todo se debe enviar NULL y se coloca (*) implicitamente
     * @param strTablas: Nombre de las tablas de la cual se obtendran los datos
     * @param strWhere: predicado de la consulta hql
     * @param parametros: parametros para en enlace de las variables que se
     * usaran con el strWhere tiene la forma tipoDato|nombre|valor
     * @param sesion : sesion activa, si es q se envía la sesion implica que no
     * se la debe cerrar
     * @return
     */
    public Object getOneSqlSession(String strCampos, String strTablas, String strWhere, List<ParametrosConsulta> parametros, Session sesion) {
        Session conn = null;
        if (sesion == null) {
            conn = HibSession.abrirSesion();
        } else {
            conn = sesion;
        }
        try {
            String strSql = null;
            /*
             * Si se trata de una consulta que devuelve todos los objetos
             * encontrados, se ejecutarás la consulta desde el from, caso
             * contrario ejecuta también el comando select con su respectivo
             * objeto a retornar
             */
            strSql = getSqlArmado(strCampos, strTablas, strWhere, "S");
            Query q = conn.createSQLQuery(strSql);
            /*
             * Agrego cada uno de los valores a las variables ligadas de la
             * consulta hql
             */
            if (parametros != null) {
                q = this.getQueryParametros(q, parametros);
            }
            return q.uniqueResult();
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * Creado: Angel Cuenca
     *
     * @param strCampos : nombre de los campos a retornar, si desea que retorne
     * todo se debe enviar NULL y se coloca (*) implicitamente
     * @param strTablas: Nombre de las tablas de la cual se obtendran los datos
     * @param strWhere: predicado de la consulta hql
     * @param parametros: parametros para en enlace de las variables que se
     * usaran con el strWhere tiene la forma tipoDato|nombre|valor
     * @return
     */
    public ClaseGeneral getOneSqlClase(String strCampos, String strTablas, String strWhere, List<ParametrosConsulta> parametros) {
        Session conn = HibSession.abrirSesion();
        try {
            String strSql = null;
            /*
             * Si se trata de una consulta que devuelve todos los objetos
             * encontrados, se ejecutarás la consulta desde el from, caso
             * contrario ejecuta también el comando select con su respectivo
             * objeto a retornar
             */
            strSql = getSqlArmado(strCampos, strTablas, strWhere, "S");
            Query q = conn.createSQLQuery(strSql);
            /*
             * Agrego cada uno de los valores a las variables ligadas de la
             * consulta hql
             */
            if (parametros != null) {
                q = this.getQueryParametros(q, parametros);
            }
            Object[] obj = (Object[]) q.uniqueResult();
            ClaseGeneral objeto = new ClaseGeneral();
            Method metodo = null;
            Class[] valorParametro;
            for (int i = 0; i < obj.length; i++) {
                int idAtributo = i + 1;
                valorParametro = new Class[1];
                valorParametro[0] = Class.forName("java.lang.Object");
                metodo = objeto.getClass().getMethod("setCampo" + idAtributo, valorParametro);
                metodo.invoke(objeto, obj[i]);
            }
            return objeto;
        } catch (Exception e) {
            return null;
        } finally {
            HibSession.cerrarSesion();
        }
    }

    /**
     * Creado: Angel Cuenca
     *
     * @param strCampos : nombre de los campos a retornar, si desea que retorne
     * todo se debe enviar NULL y se coloca (*) implicitamente
     * @param strTablas: Nombre de las tablas de la cual se obtendran los datos
     * @param strWhere: predicado de la consulta hql
     * @param parametros: parametros para en enlace de las variables que se
     * usaran con el strWhere tiene la forma tipoDato|nombre|valor
     * @param sesion : sesion activa, si es q se envía la sesion implica que no
     * se la debe cerrar
     * @return
     */
    public ClaseGeneral getOneSqlClaseSession(String strCampos, String strTablas, String strWhere, List<ParametrosConsulta> parametros, Session sesion) {
        Session conn = null;
        if (sesion == null) {
            conn = HibSession.abrirSesion();
        } else {
            conn = sesion;
        }
        try {
            String strSql = null;
            /*
             * Si se trata de una consulta que devuelve todos los objetos
             * encontrados, se ejecutarás la consulta desde el from, caso
             * contrario ejecuta también el comando select con su respectivo
             * objeto a retornar
             */
            strSql = getSqlArmado(strCampos, strTablas, strWhere, "S");
            Query q = conn.createSQLQuery(strSql);
            /*
             * Agrego cada uno de los valores a las variables ligadas de la
             * consulta hql
             */
            if (parametros != null) {
                q = this.getQueryParametros(q, parametros);
            }
            Object[] obj = (Object[]) q.uniqueResult();
            ClaseGeneral objeto = new ClaseGeneral();
            Method metodo = null;
            Class[] valorParametro;
            for (int i = 0; i < obj.length; i++) {
                int idAtributo = i + 1;
                valorParametro = new Class[1];
                valorParametro[0] = Class.forName("java.lang.Object");
                metodo = objeto.getClass().getMethod("setCampo" + idAtributo, valorParametro);
                metodo.invoke(objeto, obj[i]);
            }
            return objeto;
        } catch (Exception e) {
            return null;
        }
    }

    public Object transformarObjetoMayusculas(Object objeto) {

        try {
            Class<?> c = objeto.getClass();
            Field[] todoscampos = c.getDeclaredFields();

            for (int n = 0; n < todoscampos.length; n++) {

                Field fld = c.getDeclaredField(todoscampos[n].getName());
                String tipoDato = fld.getType().toString();

                if (tipoDato.equals("class java.lang.String")) {
                    try {
                        fld.setAccessible(true);
                        String valorant = fld.get(objeto).toString();

                        //Valido una Excepcion para los campos de email:
                        if (!(valorant.contains("@"))) {
                            valorant = valorant.toUpperCase();
                        }

                        //Valido si es un valor que no quiero que haga mayuscula
                        //Le presedo al valor de un nomayusc_
                        if (!(valorant.contains("nomay_"))) {
                            valorant = valorant.replaceAll("nomay_", "");
                        }

                        fld.set(objeto, valorant);

                    } catch (Exception e) {
                        //      System.out.println("Error Transformacion Mayusculas: "+e);
                    }
                }

            }

        } catch (Exception e) {
        }

        return objeto;
    }

    //Saca el proximo valor de la secuencia
    public Long nextSecuencia(String secuenciaNombre) {
        //NombreExquema+"."+NombreSequencia".nextcval
        //String sqlSelect = "data_usr.comun_s_codigo.nextval";
        Session conn = null;
        try {
            conn = HibSession.abrirSesion();
            Consultas consulta = new Consultas();
            Object obj = consulta.getOneSqlSession(secuenciaNombre, "dual", null, null, conn);
            return Long.parseLong(obj.toString());
        } catch (Exception e) {
            return new Long(0);
        } finally {
            HibSession.cerrarSesion();
        }

    }

    //Saca el proximo valor de la secuencia
    public Long nextSecuenciaSession(String secuenciaNombre, Session conn) {
        try {
            Consultas consulta = new Consultas();
            Object obj = consulta.getOneSqlSession(secuenciaNombre, "dual", null, null, conn);
            return Long.parseLong(obj.toString());
        } catch (Exception e) {
            return new Long(0);
        }
    }

    public int getTotalRegistros() {
        return totalRegistros;
    }

    public void setTotalRegistros(int totalRegistros) {
        this.totalRegistros = totalRegistros;
    }
}
